```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Java集合框架性能优化指南 | 技术小馆</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            background-color: #f9fafb;
            color: #1f2937;
            line-height: 1.6;
        }
        h1, h2, h3, h4, h5, h6 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
            color: #111827;
        }
        .hero {
            background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%);
            color: white;
        }
        .code-block {
            background-color: #1e293b;
            color: #f8fafc;
            border-radius: 0.5rem;
            overflow-x: auto;
        }
        .tip-card {
            background-color: #f0fdf4;
            border-left: 4px solid #10b981;
        }
        .warning-card {
            background-color: #fffbeb;
            border-left: 4px solid #f59e0b;
        }
        .danger-card {
            background-color: #fef2f2;
            border-left: 4px solid #ef4444;
        }
        .card-hover:hover {
            transform: translateY(-4px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .footer {
            background-color: #111827;
            color: #f3f4f6;
        }
        .footer a:hover {
            color: #818cf8;
        }
    </style>
</head>
<body class="antialiased">
    <!-- Hero Section -->
    <div class="hero py-20 px-4 sm:px-6 lg:px-8">
        <div class="max-w-4xl mx-auto text-center">
            <h1 class="text-4xl md:text-5xl font-bold mb-6">Java集合框架性能优化指南</h1>
            <p class="text-xl md:text-2xl opacity-90 mb-8">从大厂实战经验中提炼的集合框架最佳实践</p>
            <div class="flex justify-center space-x-4">
                <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full text-sm font-medium"><i class="fas fa-user-tie mr-2"></i>资深Java工程师</span>
                <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full text-sm font-medium"><i class="fas fa-clock mr-2"></i>10年实战经验</span>
                <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full text-sm font-medium"><i class="fas fa-fire mr-2"></i>高并发场景验证</span>
            </div>
        </div>
    </div>

    <!-- Main Content -->
    <div class="max-w-4xl mx-auto px-4 sm:px-6 lg:px-8 py-12">
        <!-- Introduction -->
        <div class="mb-16">
            <p class="text-xl text-gray-700 leading-relaxed">
                作为一个在互联网大厂摸爬滚打多年的Java老兵，我不知道踩过多少集合框架的坑，也不记得因为集合性能问题被多少次半夜call out来救火。有时候我都在想，要是早点整理这些经验，该省多少通宵加班的命啊！所以今天就把这些年踩过的坑和积累的技巧分享给大家，希望你少走弯路。
            </p>
        </div>

        <!-- 集合选择 Section -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-indigo-100 flex items-center justify-center mr-4">
                    <i class="fas fa-tools text-indigo-600 text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold">集合选择</h2>
            </div>
            
            <p class="text-lg text-gray-700 mb-6">
                Java集合就像厨房里的各种工具，看起来都能用，但用错了不仅浪费时间还可能把菜做砸。我曾经看过一个实习生用LinkedList来做频繁随机访问的操作，结果API响应时间飙到了几秒钟。项目紧急上线，我们只能通宵达旦重构代码，把集合换成ArrayList，性能立马提升了20倍。
            </p>
            
            <div class="code-block p-4 mb-6">
                <pre><code class="language-java">// 千万别这么干！随机访问用LinkedList简直是自杀
LinkedList&lt;UserProfile&gt; users = new LinkedList&lt;&gt;();
// 大量数据导入...
for (int i = 0; i &lt; 10000; i++) {
    UserProfile user = users.get(i); // 这里每次get都是O(n)的灾难
    processUser(user);
}</code></pre>
            </div>
            
            <p class="text-lg text-gray-700 mb-6">
                根据我多年的经验，以下选择基本是铁律：
            </p>
            
            <div class="grid md:grid-cols-2 gap-6 mb-8">
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300">
                    <h3 class="text-xl font-semibold mb-3 text-indigo-700"><i class="fas fa-check-circle mr-2"></i>ArrayList</h3>
                    <p class="text-gray-700">顺序访问、随机访问的首选，但别傻傻地频繁在中间插入删除</p>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300">
                    <h3 class="text-xl font-semibold mb-3 text-indigo-700"><i class="fas fa-exclamation-triangle mr-2"></i>LinkedList</h3>
                    <p class="text-gray-700">频繁在两端增删元素的场景才考虑用，比如实现队列，其他情况真的别碰它</p>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300">
                    <h3 class="text-xl font-semibold mb-3 text-indigo-700"><i class="fas fa-bolt mr-2"></i>HashMap</h3>
                    <p class="text-gray-700">绝大多数key-value场景的首选，但记得预估容量</p>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300">
                    <h3 class="text-xl font-semibold mb-3 text-indigo-700"><i class="fas fa-link mr-2"></i>LinkedHashMap</h3>
                    <p class="text-gray-700">需要保持插入顺序又要O(1)查找时才用，内存开销比HashMap大</p>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-md card-hover transition-all duration-300 md:col-span-2">
                    <h3 class="text-xl font-semibold mb-3 text-indigo-700"><i class="fas fa-tree mr-2"></i>TreeMap</h3>
                    <p class="text-gray-700">只有当你需要key自然排序时才用，否则性能比HashMap差太多</p>
                </div>
            </div>
            
            <div class="tip-card p-4 rounded-lg mb-6">
                <p class="text-gray-800">
                    <i class="fas fa-lightbulb text-green-500 mr-2"></i> 
                    我记得有个同事特别喜欢用TreeMap，理由是"看起来更优雅"，结果我们的后台管理系统响应越来越慢。排查后发现是他在用户管理模块用TreeMap存了几万用户信息，每次查询都是O(log n)而不是HashMap的近似O(1)。改了这一处，系统响应时间从平均1.2秒降到了300ms。
                </p>
            </div>
            
            <div class="mermaid mb-8">
                graph TD
                    A[选择集合类型] --> B{需要键值对?}
                    B -->|是| C{需要排序?}
                    C -->|是| D[TreeMap]
                    C -->|否| E[HashMap]
                    B -->|否| F{需要随机访问?}
                    F -->|是| G[ArrayList]
                    F -->|否| H[LinkedList]
            </div>
        </section>

        <!-- 预分配容量 Section -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-blue-100 flex items-center justify-center mr-4">
                    <i class="fas fa-expand text-blue-600 text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold">预分配容量</h2>
            </div>
            
            <p class="text-lg text-gray-700 mb-6">
                如果说我在审代码时最痛恨看到的是什么，那绝对是这行：
            </p>
            
            <div class="code-block p-4 mb-6">
                <pre><code class="language-java">ArrayList&lt;SomeObject&gt; list = new ArrayList&lt;&gt;(); // 默认容量小得可怜</code></pre>
            </div>
            
            <p class="text-lg text-gray-700 mb-6">
                尤其是接下来往里面塞上万条数据时。讲真，不预分配容量的行为在我看来就是性能灾难的前奏。
            </p>
            
            <div class="warning-card p-4 rounded-lg mb-6">
                <p class="text-gray-800">
                    <i class="fas fa-exclamation-triangle text-yellow-500 mr-2"></i> 
                    我之前参与的一个电商大促项目，就因为没有合理预分配容量，导致大促瞬间流量涌入时，系统CPU使用率飙升到90%以上。排查下来发现是大量ArrayList和HashMap在疯狂扩容和rehash。
                </p>
            </div>
            
            <div class="grid md:grid-cols-2 gap-6 mb-8">
                <div class="danger-card p-6 rounded-lg">
                    <h3 class="text-xl font-semibold mb-3 text-red-600"><i class="fas fa-times-circle mr-2"></i>灾难版本</h3>
                    <div class="code-block p-4">
                        <pre><code class="language-java">ArrayList&lt;Order&gt; orders = new ArrayList&lt;&gt;(); // 默认容量10
for (int i = 0; i &lt; 100000; i++) { // 10万订单
    orders.add(new Order()); // 可能触发多达13次扩容重新分配内存
}</code></pre>
                    </div>
                </div>
                <div class="tip-card p-6 rounded-lg">
                    <h3 class="text-xl font-semibold mb-3 text-green-600"><i class="fas fa-check-circle mr-2"></i>优化版本</h3>
                    <div class="code-block p-4">
                        <pre><code class="language-java">ArrayList&lt;Order&gt; orders = new ArrayList&lt;&gt;(100000); // 一次性分配够
for (int i = 0; i &lt; 100000; i++) {
    orders.add(new Order()); // 零扩容
}</code></pre>
                    </div>
                </div>
            </div>
            
            <div class="bg-white p-6 rounded-xl shadow-md mb-6">
                <h3 class="text-xl font-semibold mb-3 text-indigo-700"><i class="fas fa-tachometer-alt mr-2"></i>性能对比</h3>
                <p class="text-gray-700 mb-4">我给团队定了个规矩：凡是能预估容量的集合，必须在创建时就指定合适的初始容量。这一招立竿见影，系统吞吐量提升了约30%。</p>
                
                <div class="mermaid">
                    pie
                        title 扩容对性能的影响
                        "扩容操作" : 65
                        "实际业务逻辑" : 35
                </div>
            </div>
            
            <div class="bg-white p-6 rounded-xl shadow-md">
                <h3 class="text-xl font-semibold mb-3 text-indigo-700"><i class="fas fa-map-marked-alt mr-2"></i>HashMap容量小技巧</h3>
                <div class="code-block p-4 mb-4">
                    <pre><code class="language-java">// 参数通常有30多个，预分配空间避免扩容
Map&lt;String, String&gt; params = new HashMap&lt;&gt;(64);</code></pre>
                </div>
                <p class="text-gray-700">
                    再补充一个小技巧：HashMap的容量会被调整为2的幂，所以给定初始容量时，实际分配的空间会是最接近的2的幂。比如给33，实际会分配64。记住这点可以更精确地控制内存使用。
                </p>
            </div>
        </section>

        <!-- 集合的并发灾难 Section -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-red-100 flex items-center justify-center mr-4">
                    <i class="fas fa-bolt text-red-600 text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold">集合的并发灾难</h2>
            </div>
            
            <div class="danger-card p-4 rounded-lg mb-6">
                <p class="text-gray-800">
                    <i class="fas fa-exclamation-circle text-red-500 mr-2"></i> 
                    我参与过一个故障复盘，一个金融系统在升级后偶发数据丢失，查了好几天才发现是多线程环境下错用ArrayList导致的。那个团队的同学把用户交易记录放在一个ArrayList里，多个线程并发读写，结果赔了不少钱...
                </p>
            </div>
            
            <div class="code-block p-4 mb-6">
                <pre><code class="language-java">// 生产事故级代码
List&lt;Transaction&gt; transactions = new ArrayList&lt;&gt;(); // 非线程安全
// 多线程并发调用
public void addTransaction(Transaction tx) {
    transactions.add(tx); // 灾难现场！
}</code></pre>
            </div>
            
            <div class="bg-white p-6 rounded-xl shadow-md mb-8">
                <h3 class="text-xl font-semibold mb-4 text-indigo-700"><i class="fas fa-shield-alt mr-2"></i>多线程环境集合使用原则</h3>
                <ul class="space-y-3">
                    <li class="flex items-start">
                        <div class="flex-shrink-0 h-6 w-6 rounded-full bg-green-100 flex items-center justify-center mr-3">
                            <i class="fas fa-check text-green-600 text-sm"></i>
                        </div>
                        <span class="text-gray-700">优先考虑concurrent包下的并发集合，如ConcurrentHashMap</span>
                    </li>
                    <li class="flex items-start">
                        <div class="flex-shrink-0 h-6 w-6 rounded-full bg-red-100 flex items-center justify-center mr-3">
                            <i class="fas fa-times text-red-600 text-sm"></i>
                        </div>
                        <span class="text-gray-700">不要用Collections.synchronizedXXX包装，性能差，还容易死锁</span>
                    </li>
                    <li class="flex items-start">
                        <div class="flex-shrink-0 h-6 w-6 rounded-full bg-green-100 flex items-center justify-center mr-3">
                            <i class="fas fa-check text-green-600 text-sm"></i>
                        </div>
                        <span class="text-gray-700">读多写少场景，考虑CopyOnWriteArrayList/Set</span>
                    </li>
                    <li class="flex items-start">
                        <div class="flex-shrink-0 h-6 w-6 rounded-full bg-green-100 flex items-center justify-center mr-3">
                            <i class="fas fa-check text-green-600 text-sm"></i>
                        </div>
                        <span class="text-gray-700">如需在遍历过程中可能有其他线程修改集合，务必用并发集合</span>
                    </li>
                </ul>
            </div>
            
            <div class="grid md:grid-cols-2 gap-6">
                <div class="danger-card p-6 rounded-lg">
                    <h3 class="text-xl font-semibold mb-3 text-red-600"><i class="fas fa-times-circle mr-2"></i>老代码：问题多多</h3>
                    <div class="code-block p-4">
                        <pre><code class="language-java">Map&lt;Long, UserAccount&gt; accountCache = 
    Collections.synchronizedMap(new HashMap&lt;&gt;());</code></pre>
                    </div>
                </div>
                <div class="tip-card p-6 rounded-lg">
                    <h3 class="text-xl font-semibold mb-3 text-green-600"><i class="fas fa-check-circle mr-2"></i>改造后：性能提升5倍</h3>
                    <div class="code-block p-4">
                        <pre><code class="language-java">Map&lt;Long, UserAccount&gt; accountCache = 
    new ConcurrentHashMap&lt;&gt;(1024);</code></pre>
                    </div>
                </div>
            </div>
            
            <div class="tip-card p-4 rounded-lg mt-6">
                <p class="text-gray-800">
                    <i class="fas fa-lightbulb text-green-500 mr-2"></i> 
                    改造后系统支持的并发用户数从2000提升到超过10000，CPU使用率却下降了40%。ConcurrentHashMap是我Java开发生涯中最感谢的类之一。它的设计非常巧妙，分段锁机制让并发写入时锁粒度变小，大大提高了并发性能。
                </p>
            </div>
        </section>

        <!-- HashMap调优 Section -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-purple-100 flex items-center justify-center mr-4">
                    <i class="fas fa-sliders-h text-purple-600 text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold">HashMap调优</h2>
            </div>
            
            <p class="text-lg text-gray-700 mb-6">
                HashMap虽好，但用不好照样是灾难。我曾经遇到过一个诡异的性能问题：一个API在大部分情况下响应很快，但偶尔会特别慢。排查后发现是HashMap的哈希冲突导致的。
            </p>
            
            <div class="code-block p-4 mb-6">
                <pre><code class="language-java">// 问题代码
Map&lt;CustomerId, CustomerInfo&gt; customerMap = new HashMap&lt;&gt;();
// 大量CustomerId的hashCode冲突，导致严重性能问题</code></pre>
            </div>
            
            <div class="bg-white p-6 rounded-xl shadow-md mb-8">
                <h3 class="text-xl font-semibold mb-4 text-indigo-700"><i class="fas fa-magic mr-2"></i>HashMap优化技巧</h3>
                <ul class="space-y-3">
                    <li class="flex items-start">
                        <div class="flex-shrink-0 h-6 w-6 rounded-full bg-blue-100 flex items-center justify-center mr-3">
                            <i class="fas fa-star text-blue-600 text-sm"></i>
                        </div>
                        <span class="text-gray-700">优化key的hashCode()实现，确保均匀分布</span>
                    </li>
                    <li class="flex items-start">
                        <div class="flex-shrink-0 h-6 w-6 rounded-full bg-blue-100 flex items-center justify-center mr-3">
                            <i class="fas fa-star text-blue-600 text-sm"></i>
                        </div>
                        <span class="text-gray-700">使用更复杂的数据结构作为key，比如合成键</span>
                    </li>
                    <li class="flex items-start">
                        <div class="flex-shrink-0 h-6 w-6 rounded-full bg-blue-100 flex items-center justify-center mr-3">
                            <i class="fas fa-star text-blue-600 text-sm"></i>
                        </div>
                        <span class="text-gray-700">适当增大HashMap的初始容量减少冲突概率</span>
                    </li>
                    <li class="flex items-start">
                        <div class="flex-shrink-0 h-6 w-6 rounded-full bg-blue-100 flex items-center justify-center mr-3">
                            <i class="fas fa-star text-blue-600 text-sm"></i>
                        </div>
                        <span class="text-gray-700">调整负载因子(默认0.75)，关注查询性能时可适当调低</span>
                    </li>
                </ul>
            </div>
            
            <div class="code-block p-4 mb-6">
                <pre><code class="language-java">// 降低负载因子，减少哈希冲突概率，代价是更多内存消耗
Map&lt;String, Object&gt; cache = new HashMap&lt;&gt;(1000, 0.5f);</code></pre>
            </div>
            
            <div class="tip-card p-4 rounded-lg">
                <p class="text-gray-800">
                    <i class="fas fa-lightbulb text-green-500 mr-2"></i> 
                    我在一个交易检索系统中使用这个技巧后，99线响应时间从120ms降到了70ms，虽然多消耗了一些内存，但在当时的场景下非常值得。
                </p>
            </div>
        </section>

        <!-- 集合迭代的性能陷阱 Section -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-orange-100 flex items-center justify-center mr-4">
                    <i class="fas fa-sync-alt text-orange-600 text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold">集合迭代的性能陷阱</h2>
            </div>
            
            <p class="text-lg text-gray-700 mb-6">
                迭代是集合操作中最常见也最容易被忽视的性能杀手。我曾经看到一段代码，在循环中反复调用List.contains()方法检查元素是否存在：
            </p>
            
            <div class="code-block p-4 mb-6">
                <pre><code class="language-java">List&lt;String&gt; codes = getProductCodes(); // 可能有成千上万个产品代码
for (Order order : orders) {
    if (codes.contains(order.getProductCode())) { // O(n)复杂度！
        // 处理订单
    }
}</code></pre>
            </div>
            
            <p class="text-lg text-gray-700 mb-6">
                这代码看起来没什么问题，但如果orders和codes都很大，性能简直是灾难性的。每次contains()调用都是O(n)复杂度，嵌套循环使总体复杂度变成了O(m*n)。
            </p>
            
            <div class="tip-card p-4 rounded-lg mb-6">
                <h4 class="font-semibold text-green-700 mb-2"><i class="fas fa-lightbulb mr-2"></i>优化方案</h4>
                <div class="code-block p-4">
                    <pre><code class="language-java">Set&lt;String&gt; codeSet = new HashSet&lt;&gt;(getProductCodes());
for (Order order : orders) {
    if (codeSet.contains(order.getProductCode())) { // O(1)复杂度！
        // 处理订单
    }
}</code></pre>
                </div>
                <p class="mt-2 text-gray-800">这一改动在我们的系统中直接将一个任务的处理时间从几分钟降到了几秒钟。</p>
            </div>
            
            <div class="warning-card p-4 rounded-lg mb-6">
                <p class="text-gray-800">
                    <i class="fas fa-exclamation-triangle text-yellow-500 mr-2"></i> 
                    另一个经常被忽视的问题是ConcurrentModificationException（并发修改异常）。我见过无数开发者被这个异常困扰，然后写出这种代码：
                </p>
                <div class="code-block p-4 mt-2">
                    <pre><code class="language-java">// 灾难代码
List&lt;User&gt; users = getUserList();
for (User user : users) {
    if (user.isInactive()) {
        users.remove(user); // 边遍历边修改，必然异常
    }
}</code></pre>
                </div>
            </div>
            
            <div class="bg-white p-6 rounded-xl shadow-md">
                <h3 class="text-xl font-semibold mb-4 text-indigo-700"><i class="fas fa-code mr-2"></i>正确的遍历删除方式</h3>
                <div class="grid md:grid-cols-2 gap-6">
                    <div>
                        <h4 class="font-medium text-gray-800 mb-2">Java 8前</h4>
                        <div class="code-block p-4">
                            <pre><code class="language-java">Iterator&lt;User&gt; iterator = users.iterator();
while (iterator.hasNext()) {
    User user = iterator.next();
    if (user.isInactive()) {
        iterator.remove(); // 正确方式
    }
}</code></pre>
                        </div>
                    </div>
                    <div>
                        <h4 class="font-medium text-gray-800 mb-2">Java 8+更优雅的方式</h4>
                        <div class="code-block p-4">
                            <pre><code class="language-java">users.removeIf(User::isInactive);</code></pre>
                        </div>
                    </div>
                </div>
                <p class="mt-4 text-gray-700">
                    这些细节虽小，但在代码质量和系统性能方面却有天壤之别。
                </p>
            </div>
        </section>

        <!-- 用对工具，事半功倍 Section -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-green-100 flex items-center justify-center mr-4">
                    <i class="fas fa-tools text-green-600 text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold">用对工具，事半功倍</h2>
            </div>
            
            <div class="mb-12">
                <h3 class="text-2xl font-semibold mb-6 text-gray-800 flex items-center">
                    <i class="fas fa-stream mr-3 text-blue-500"></i>流式处理与传统循环的选择
                </h3>
                
                <p class="text-lg text-gray-700 mb-6">
                    Java 8引入的Stream API很酷，但不是万能药。根据我的实战经验，在关注性能的场景下，要谨慎使用Stream：
                </p>
                
                <div class="grid md:grid-cols-2 gap-6 mb-6">
                    <div>
                        <h4 class="font-medium text-gray-800 mb-2">Stream版本 - 看起来很酷</h4>
                        <div class="code-block p-4">
                            <pre><code class="language-java">List&lt;Transaction&gt; highValueTransactions = transactions.stream()
    .filter(tx -> tx.getValue() > 1000)
    .filter(tx -> tx.getStatus() == Status.COMPLETED)
    .collect(Collectors.toList());</code></pre>
                        </div>
                    </div>
                    <div>
                        <h4 class="font-medium text-gray-800 mb-2">传统循环 - 通常性能更好</h4>
                        <div class="code-block p-4">
                            <pre><code class="language-java">List&lt;Transaction&gt; highValueTransactions = new ArrayList&lt;&gt;();
for (Transaction tx : transactions) {
    if (tx.getValue() > 1000 && tx.getStatus() == Status.COMPLETED) {
        highValueTransactions.add(tx);
    }
}</code></pre>
                        </div>
                    </div>
                </div>
                
                <p class="text-lg text-gray-700 mb-6">
                    我在一个批处理系统中测试过，对于简单操作，传统for循环通常比Stream快20%-30%。当然，如果代码可读性和维护性更重要，Stream仍然是不错的选择。
                </p>
                
                <div class="tip-card p-4 rounded-lg">
                    <h4 class="font-semibold text-green-700 mb-2"><i class="fas fa-lightbulb mr-2"></i>Stream的正确使用场景</h4>
                    <div class="code-block p-4">
                        <pre><code class="language-java">// 多核环境下处理大数据集的利器
transactions.parallelStream()
    .filter(tx -> tx.getValue() > 1000)
    .forEach(this::processTx);</code></pre>
                    </div>
                    <p class="mt-2 text-gray-800">
                        但别滥用parallelStream！我见过一个服务因为滥用并行流而CPU飙升、线程耗尽的惨案。记住：只有在数据量足够大、每个元素处理逻辑足够重且相互独立的情况下，并行流才有明显优势。
                    </p>
                </div>
            </div>
            
            <div class="bg-white p-6 rounded-xl shadow-md">
                <h3 class="text-2xl font-semibold mb-6 text-gray-800 flex items-center">
                    <i class="fas fa-exclamation-triangle mr-3 text-yellow-500"></i>慎用奇技淫巧
                </h3>
                
                <p class="text-lg text-gray-700 mb-6">
                    我接手过一个"优化过度"的项目，前任用了各种黑科技来提升HashMap的性能：自定义哈希算法、魔改负载因子、甚至尝试绕过JVM的内存管理。结果呢？代码难以维护，而且实际性能提升微乎其微。
                </p>
                
                <div class="bg-blue-50 p-6 rounded-lg">
                    <h4 class="text-xl font-semibold mb-4 text-blue-700"><i class="fas fa-flag-checkered mr-2"></i>集合优化黄金法则</h4>
                    <ol class="list-decimal pl-5 space-y-3 text-gray-700">
                        <li>先选对数据结构</li>
                        <li>合理预估容量</li>
                        <li>用性能测试工具（如JMH）量化性能问题</li>
                        <li>针对真正的瓶颈优化</li>
                    </ol>
                    <p class="mt-4 text-gray-700">
                        绝大多数时候，这四点就足够了。不要过度沉迷于那些所谓的"奇技淫巧"，那样通常会适得其反。
                    </p>
                </div>
            </div>
        </section>

        <!-- 订单系统性能优化 Case Study -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-indigo-100 flex items-center justify-center mr-4">
                    <i class="fas fa-chart-line text-indigo-600 text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold">订单系统性能优化案例</h2>
            </div>
            
            <p class="text-lg text-gray-700 mb-6">
                我曾经接手过一个电商订单系统的性能优化任务。系统在节假日高峰期间响应极慢，有时甚至会超时。通过分析，我们发现主要瓶颈是在订单处理逻辑中的几个集合操作：
            </p>
            
            <div class="grid md:grid-cols-2 gap-6 mb-8">
                <div class="danger-card p-6 rounded-lg">
                    <h3 class="text-xl font-semibold mb-3 text-red-600"><i class="fas fa-exclamation-triangle mr-2"></i>优化前</h3>
                    <div class="code-block p-4">
                        <pre><code class="language-java">// 1. 使用ArrayList存储数百万订单
List&lt;Order&gt; allOrders = orderRepository.findAll();

// 2. 查找特定用户的订单，每次都要全表扫描
List&lt;Order&gt; userOrders = new ArrayList&lt;&gt;();
for (Order order : allOrders) {
    if (order.getUserId().equals(userId)) {
        userOrders.add(order);
    }
}

// 3. 统计各种状态的订单数量
Map&lt;OrderStatus, Integer&gt; statusCounts = new HashMap&lt;&gt;();
for (Order order : userOrders) {
    OrderStatus status = order.getStatus();
    Integer count = statusCounts.getOrDefault(status, 0);
    statusCounts.put(status, count + 1);
}</code></pre>
                    </div>
                </div>
                <div class="tip-card p-6 rounded-lg">
                    <h3 class="text-xl font-semibold mb-3 text-green-600"><i class="fas fa-check-circle mr-2"></i>优化后</h3>
                    <div class="code-block p-4">
                        <pre><code class="language-java">// 1. 按用户ID索引订单
Map&lt;Long, List&lt;Order&gt;&gt; ordersByUser = new HashMap&lt;&gt;(10000);
List&lt;Order&gt; orders = orderRepository.findAll();
for (Order order : orders) {
    ordersByUser.computeIfAbsent(order.getUserId(), 
        k -> new ArrayList&lt;&gt;()).add(order);
}

// 2. 直接获取特定用户的订单，O(1)复杂度
List&lt;Order&gt; userOrders = ordersByUser.getOrDefault(userId, 
    Collections.emptyList());

// 3. 使用Java 8的分组功能更高效统计
Map&lt;OrderStatus, Long&gt; statusCounts = userOrders.stream()
    .collect(Collectors.groupingBy(
        Order::getStatus, 
        Collectors.counting()
    ));</code></pre>
                    </div>
                </div>
            </div>
            
            <div class="bg-white p-6 rounded-xl shadow-md">
                <div class="flex flex-col md:flex-row items-center">
                    <div class="md:w-1/2 mb-6 md:mb-0">
                        <div class="mermaid">
                            pie
                                title 性能提升对比
                                "响应时间优化" : 75
                                "吞吐量提升" : 25
                        </div>
                    </div>
                    <div class="md:w-1/2 md:pl-8">
                        <h3 class="text-2xl font-semibold mb-4 text-gray-800">优化成果</h3>
                        <ul class="space-y-3 text-gray-700">
                            <li class="flex items-start">
                                <div class="flex-shrink-0 h-6 w-6 rounded-full bg-green-100 flex items-center justify-center mr-3">
                                    <i class="fas fa-check text-green-600 text-sm"></i>
                                </div>
                                <span>系统峰值处理能力从每秒2000单提升到每秒8000单</span>
                            </li>
                            <li class="flex items-start">
                                <div class="flex-shrink-0 h-6 w-6 rounded-full bg-green-100 flex items-center justify-center mr-3">
                                    <i class="fas fa-check text-green-600 text-sm"></i>
                                </div>
                                <span>平均响应时间从1.2秒降到了300ms</span>
                            </li>
                            <li class="flex items-start">
                                <div class="flex-shrink-0 h-6 w-6 rounded-full bg-green-100 flex items-center justify-center mr-3">
                                    <i class="fas fa-check text-green-600 text-sm"></i>
                                </div>
                                <span>CPU使用率降低40%</span>
                            </li>
                        </ul>
                        <p class="mt-4 text-gray-700">
                            看似简单的集合选择和使用方式调整，却带来了如此巨大的性能提升。
                        </p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Conclusion -->
        <div class="bg-white p-8 rounded-xl shadow-md text-center">
            <i class="fas fa-graduation-cap text-5xl text-indigo-600 mb-6"></i>
            <h2 class="text-3xl font-bold mb-4">关键要点总结</h2>
            <p class="text-xl text-gray-700 mb-8 leading-relaxed">
                集合优化看似简单，但对系统性能影响巨大。<br>
                选择合适的数据结构、合理预分配容量、注意线程安全、避免常见陷阱，<br>
                这些简单的原则就能带来显著的性能提升。
            </p>
            <div class="inline-flex items-center px-6 py-3 bg-indigo-600 text-white rounded-full font-medium hover:bg-indigo-700 transition-colors duration-300">
                <i class="fas fa-book mr-2"></i> 立即应用这些技巧优化你的代码
            </div>
        </div>
    </div>

    <!-- Footer -->
    <footer class="footer py-8 px-4 sm:px-6 lg:px-8 text-center">
        <div class="max-w-4xl mx-auto">
            <div class="flex flex-col items-center">
                <h3 class="text-xl font-semibold mb-2">技术小馆</h3>
                <a href="http://www.yuque.com/jtostring" class="text-indigo-300 hover:text-indigo-100 transition-colors duration-300">
                    <i class="fas fa-link mr-1"></i> http://www.yuque.com/jtostring
                </a>
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: { 
                useMaxWidth: false,
                htmlLabels: true
            }
        });
    </script>
</body>
</html>
```